"""
    多线程操作
    def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None):
    * 在这里的主要作用是强制要求某些参数（位于 * 之后的那些，如 daemon）必须通过关键字参数的形式传入

    在Python中关键字参数必须在位置参数之后
    在Python中，当你调用函数时，位置参数必须出现在关键字参数之前。这意味着你不能在同一个函数调用中先指定关键字参数再指定位置参数。例如，下面的调用是非法的：
    function(name="Alice", 20)  # 错误：关键字参数之后还有位置参数

"""
import threading
import time
from threading import Thread
from traceback import print_last

# 定义一个全局锁对象
print_lock = threading.Lock()
#print_lock.acquire()
#print_lock.release()
#with print_lock:

def cla(obj):
    time.sleep(1)
    print(f"{threading.current_thread().name} 这是cla 方法 {obj} \n", end="")

t1 = Thread(target=cla, name="线程1", args=("this t1", ))
t2 = Thread(target=cla, name="线程2", args=("this t2", ))
t3 = Thread(target=cla, name="线程3", args=("this t3", ))
t4 = Thread(target=cla, name="线程4", args=("this t4", ))

#自定义一个线程类
class MyThread(Thread):
    a = None
    b = None
    def __init__(self, name, *args, **kwargs):
        super().__init__(name=name, args=args)
        #self.name = name
        self.a = args[0]
        self.b = args[1]

    def run(self):
        time.sleep(1)
        #print(f"{threading.current_thread().name} 这是cla 方法 a = {self.a}, b = {self.b} \n", end="")
        with print_lock:
            print(f"{threading.current_thread().name} 这是cla 方法 a = {self.a}, b = {self.b}")


if __name__ == '__main__':
    # 创建并启动线程，直接传递位置参数
    t1 = MyThread("线程1", 1, 2)  # 直接传递位置参数
    t2 = MyThread("线程2", 1, 2)  # 直接传递位置参数
    t3 = MyThread("线程3", 1, 2)  # 直接传递位置参数
    t4 = MyThread("线程4", 1, 2)  # 直接传递位置参数
    t1.start()  # 启动线程
    t2.start()
    t3.start()
    t4.start()
    t1.join()  # 等待线程完成
    t2.join()
    t3.join()
    t4.join()

    print("主线程执行完成")
